{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "图像分类是根据图像的语义信息对不同类别图像进行区分，是计算机视觉中重要的基础问题，是物体检测、图像分割、物体跟踪、行为分析、人脸识别等其他高层次视觉任务的基础。图像分类在许多领域都有着广泛的应用，如：安防领域的人脸识别和智能视频分析等，交通领域的交通场景识别，互联网领域基于内容的图像检索和相册自动归类，医学领域的图像识别等。\n",
    "\n",
    "上一节主要介绍了卷积神经网络常用的一些基本模块，本节将基于眼疾分类数据集iChallenge-PM，对图像分类领域的经典卷积神经网络进行剖析，介绍如何应用这些基础模块构建卷积神经网络，解决图像分类问题。涵盖如下卷积神经网络：\n",
    "\n",
    "- LeNet：Yan LeCun等人于1998年第一次将卷积神经网络应用到图像分类任务上[1]，在手写数字识别任务上取得了巨大成功。\n",
    "\n",
    "- AlexNet：Alex Krizhevsky等人在2012年提出了AlexNet[2], 并应用在大尺寸图片数据集ImageNet上，获得了2012年ImageNet比赛冠军(ImageNet Large Scale Visual Recognition Challenge，ILSVRC）。\n",
    "\n",
    "- VGG：Simonyan和Zisserman于2014年提出了VGG网络结构[3]，是当前最流行的卷积神经网络之一，由于其结构简单、应用性极强而深受广受研究者欢迎。\n",
    "\n",
    "- GoogLeNet：Christian Szegedy等人在2014提出了GoogLeNet[4]，并取得了2014年ImageNet比赛冠军。\n",
    "\n",
    "- ResNet：Kaiming He等人在2015年提出了ResNet[5]，通过引入残差模块加深网络层数，在ImagNet数据集上的识别错误率降低到3.6%，超越了人眼识别水平。ResNet的设计思想深刻的影响了后来的深度神经网络的设计。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# LeNet\n",
    "\n",
    "LeNet是最早的卷积神经网络之一[1]。1998年，Yan LeCun第一次将LeNet卷积神经网络应用到图像分类上，在手写数字识别任务中取得了巨大成功。LeNet通过连续使用卷积和池化层的组合提取图像特征，其架构如 **图1** 所示，这里展示的是作者论文中的LeNet-5模型：\n",
    "<br></br>\n",
    "<center><img src=\"https://ai-studio-static-online.cdn.bcebos.com/7323b32f61f24eba809db0b71fcd69eee7bd2921a81d42b4bd0e6f86c89efd51\" width = \"700\"></center>\n",
    "<center><br>图1：LeNet模型网络结构示意图</br></center>\n",
    "<br></br>\n",
    "\n",
    "* 第一轮卷积和池化：卷积提取图像中包含的特征模式（激活函数使用sigmoid），图像尺寸从32减小到28。经过池化层可以降低输出特征图对空间位置的敏感性，图像尺寸减到14。\n",
    "\n",
    "* 第二轮卷积和池化：卷积操作使图像尺寸减小到10，经过池化后变成5。\n",
    "\n",
    "* 第三轮卷积：将经过第3次卷积提取到的特征图输入到全连接层。第一个全连接层的输出神经元的个数是64，第二个全连接层的输出神经元个数是分类标签的类别数，对于手写数字识别其大小是10。然后使用Softmax激活函数即可计算出每个类别的预测概率。\n",
    "\n",
    "------\n",
    "**【提示】：**\n",
    "\n",
    "卷积层的输出特征图如何当作全连接层的输入使用呢？\n",
    "\n",
    "卷积层的输出数据格式是$[N, C, H, W]$，在输入全连接层的时候，会自动将数据拉平，\n",
    "\n",
    "也就是对每个样本，自动将其转化为长度为$K$的向量，\n",
    "\n",
    "其中$K = C \\times H \\times W$，一个mini-batch的数据维度变成了$N\\times K$的二维向量。\n",
    "\n",
    "------\n",
    "\n",
    "## LeNet在手写数字识别上的应用\n",
    "\n",
    "LeNet网络的实现代码如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# 导入需要的包\n",
    "import paddle\n",
    "import paddle.fluid as fluid\n",
    "import numpy as np\n",
    "from paddle.fluid.dygraph.nn import Conv2D, Pool2D, FC\n",
    "\n",
    "# 定义 LeNet 网络结构\n",
    "class LeNet(fluid.dygraph.Layer):\n",
    "    def __init__(self, name_scope, num_classes=1):\n",
    "        super(LeNet, self).__init__(name_scope)\n",
    "        name_scope = self.full_name()\n",
    "        # 创建卷积和池化层块，每个卷积层使用Sigmoid激活函数，后面跟着一个2x2的池化\n",
    "        self.conv1 = Conv2D(name_scope, num_filters=6, filter_size=5, act='sigmoid')\n",
    "        self.pool1 = Pool2D(name_scope, pool_size=2, pool_stride=2, pool_type='max')\n",
    "        self.conv2 = Conv2D(name_scope, num_filters=16, filter_size=5, act='sigmoid')\n",
    "        self.pool2 = Pool2D(name_scope, pool_size=2, pool_stride=2, pool_type='max')\n",
    "        # 创建第3个卷积层\n",
    "        self.conv3 = Conv2D(name_scope, num_filters=120, filter_size=4, act='sigmoid')\n",
    "        # 创建全连接层，第一个全连接层的输出神经元个数为64， 第二个全连接层输出神经元个数为分裂标签的类别数\n",
    "        self.fc1 = FC(name_scope, size=64, act='sigmoid')\n",
    "        self.fc2 = FC(name_scope, size=num_classes)\n",
    "    # 网络的前向计算过程\n",
    "    def forward(self, x):\n",
    "        x = self.conv1(x)\n",
    "        x = self.pool1(x)\n",
    "        x = self.conv2(x)\n",
    "        x = self.pool2(x)\n",
    "        x = self.conv3(x)\n",
    "        x = self.fc1(x)\n",
    "        x = self.fc2(x)\n",
    "        return x\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "下面的程序使用随机数作为输入，查看经过LeNet-5的每一层作用之后，输出数据的形状"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[<paddle.fluid.dygraph.nn.Conv2D object at 0x7f130a6f6d10>, <paddle.fluid.dygraph.nn.Pool2D object at 0x7f130a6f6d70>, <paddle.fluid.dygraph.nn.Conv2D object at 0x7f130a6f6dd0>, <paddle.fluid.dygraph.nn.Pool2D object at 0x7f130a6f6e30>, <paddle.fluid.dygraph.nn.Conv2D object at 0x7f130a6f6e90>, <paddle.fluid.dygraph.nn.FC object at 0x7f130a6f6ef0>, <paddle.fluid.dygraph.nn.FC object at 0x7f130a6f6f50>]\n",
      "LeNet/LeNet_0/Conv2D_0 [3, 6, 24, 24] [6, 3, 5, 5] [6]\n",
      "LeNet/LeNet_0/Pool2D_0 [3, 6, 12, 12]\n",
      "LeNet/LeNet_0/Conv2D_1 [3, 16, 8, 8] [16, 6, 5, 5] [16]\n",
      "LeNet/LeNet_0/Pool2D_1 [3, 16, 4, 4]\n",
      "LeNet/LeNet_0/Conv2D_2 [3, 120, 1, 1] [120, 16, 4, 4] [120]\n",
      "LeNet/LeNet_0/FC_0 [3, 64] [120, 64] [64]\n",
      "LeNet/LeNet_0/FC_1 [3, 10] [64, 10] [10]\n"
     ]
    }
   ],
   "source": [
    "# 输入数据形状是 [N, 3, H, W]\n",
    "# 这里用np.random创建一个随机数组作为输入数据\n",
    "x = np.random.randn(*[3,3,28,28])\n",
    "x = x.astype('float32')\n",
    "with fluid.dygraph.guard():\n",
    "    # 创建LeNet类的实例，指定模型名称和分类的类别数目\n",
    "    m = LeNet('LeNet', num_classes=10)\n",
    "    # 通过调用LeNet从基类继承的sublayers()函数，\n",
    "    # 查看LeNet中所包含的子层\n",
    "    print(m.sublayers())\n",
    "    x = fluid.dygraph.to_variable(x)\n",
    "    for item in m.sublayers():\n",
    "        # item是LeNet类中的一个子层\n",
    "        # 查看经过子层之后的输出数据形状\n",
    "        x = item(x)\n",
    "        if len(item.parameters())==2:\n",
    "            # 查看卷积和全连接层的数据和参数的形状，\n",
    "            # 其中item.parameters()[0]是权重参数w，item.parameters()[1]是偏置参数b\n",
    "            print(item.full_name(), x.shape, item.parameters()[0].shape, item.parameters()[1].shape)\n",
    "        else:\n",
    "            # 池化层没有参数\n",
    "            print(item.full_name(), x.shape)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "start training ... \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[==================================================]t/train-images-idx3-ubyte.gz not found, downloading https://dataset.bj.bcebos.com/mnist/train-images-idx3-ubyte.gz\n",
      "[==================================================]t/train-labels-idx1-ubyte.gz not found, downloading https://dataset.bj.bcebos.com/mnist/train-labels-idx1-ubyte.gz\n",
      "[==================================================]t/t10k-images-idx3-ubyte.gz not found, downloading https://dataset.bj.bcebos.com/mnist/t10k-images-idx3-ubyte.gz\n",
      "[==================================================]t/t10k-labels-idx1-ubyte.gz not found, downloading https://dataset.bj.bcebos.com/mnist/t10k-labels-idx1-ubyte.gz\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 0, batch_id: 0, loss is: [2.42813]\n",
      "epoch: 0, batch_id: 1000, loss is: [2.294817]\n",
      "epoch: 0, batch_id: 2000, loss is: [2.3333888]\n",
      "epoch: 0, batch_id: 3000, loss is: [2.2773566]\n",
      "epoch: 0, batch_id: 4000, loss is: [2.264032]\n",
      "epoch: 0, batch_id: 5000, loss is: [2.3286614]\n",
      "[validation] accuracy/loss: 0.2865000069141388/2.2650628089904785\n",
      "epoch: 1, batch_id: 0, loss is: [2.2556887]\n",
      "epoch: 1, batch_id: 1000, loss is: [2.2007344]\n",
      "epoch: 1, batch_id: 2000, loss is: [2.2343373]\n",
      "epoch: 1, batch_id: 3000, loss is: [1.9010919]\n",
      "epoch: 1, batch_id: 4000, loss is: [1.4860792]\n",
      "epoch: 1, batch_id: 5000, loss is: [1.7839715]\n",
      "[validation] accuracy/loss: 0.6508999466896057/1.2425142526626587\n",
      "epoch: 2, batch_id: 0, loss is: [1.0747683]\n",
      "epoch: 2, batch_id: 1000, loss is: [0.8407308]\n",
      "epoch: 2, batch_id: 2000, loss is: [0.79958785]\n",
      "epoch: 2, batch_id: 3000, loss is: [0.4308278]\n",
      "epoch: 2, batch_id: 4000, loss is: [0.46389332]\n",
      "epoch: 2, batch_id: 5000, loss is: [0.6651041]\n",
      "[validation] accuracy/loss: 0.858199954032898/0.5148802995681763\n",
      "epoch: 3, batch_id: 0, loss is: [0.39135882]\n",
      "epoch: 3, batch_id: 1000, loss is: [0.32209522]\n",
      "epoch: 3, batch_id: 2000, loss is: [0.3276852]\n",
      "epoch: 3, batch_id: 3000, loss is: [0.15407428]\n",
      "epoch: 3, batch_id: 4000, loss is: [0.24255577]\n",
      "epoch: 3, batch_id: 5000, loss is: [0.2674939]\n",
      "[validation] accuracy/loss: 0.9054999947547913/0.32995927333831787\n",
      "epoch: 4, batch_id: 0, loss is: [0.22237864]\n",
      "epoch: 4, batch_id: 1000, loss is: [0.22879934]\n",
      "epoch: 4, batch_id: 2000, loss is: [0.2324216]\n",
      "epoch: 4, batch_id: 3000, loss is: [0.07491662]\n",
      "epoch: 4, batch_id: 4000, loss is: [0.1408459]\n",
      "epoch: 4, batch_id: 5000, loss is: [0.15748075]\n",
      "[validation] accuracy/loss: 0.9257999658584595/0.2552158832550049\n"
     ]
    }
   ],
   "source": [
    "# -*- coding: utf-8 -*-\n",
    "\n",
    "# LeNet 识别手写数字\n",
    "\n",
    "import os\n",
    "import random\n",
    "import paddle\n",
    "import paddle.fluid as fluid\n",
    "import numpy as np\n",
    "\n",
    "# 定义训练过程\n",
    "def train(model):\n",
    "    print('start training ... ')\n",
    "    model.train()\n",
    "    epoch_num = 5\n",
    "    opt = fluid.optimizer.Momentum(learning_rate=0.001, momentum=0.9)\n",
    "    # 使用Paddle自带的数据读取器\n",
    "    train_loader = paddle.batch(paddle.dataset.mnist.train(), batch_size=10)\n",
    "    valid_loader = paddle.batch(paddle.dataset.mnist.test(), batch_size=10)\n",
    "    for epoch in range(epoch_num):\n",
    "        for batch_id, data in enumerate(train_loader()):\n",
    "            # 调整输入数据形状和类型\n",
    "            x_data = np.array([item[0] for item in data], dtype='float32').reshape(-1, 1, 28, 28)\n",
    "            y_data = np.array([item[1] for item in data], dtype='int64').reshape(-1, 1)\n",
    "            # 将numpy.ndarray转化成Tensor\n",
    "            img = fluid.dygraph.to_variable(x_data)\n",
    "            label = fluid.dygraph.to_variable(y_data)\n",
    "            # 计算模型输出\n",
    "            logits = model(img)\n",
    "            # 计算损失函数\n",
    "            loss = fluid.layers.softmax_with_cross_entropy(logits, label)\n",
    "            avg_loss = fluid.layers.mean(loss)\n",
    "            if batch_id % 1000 == 0:\n",
    "                print(\"epoch: {}, batch_id: {}, loss is: {}\".format(epoch, batch_id, avg_loss.numpy()))\n",
    "            avg_loss.backward()\n",
    "            opt.minimize(avg_loss)\n",
    "            model.clear_gradients()\n",
    "\n",
    "        model.eval()\n",
    "        accuracies = []\n",
    "        losses = []\n",
    "        for batch_id, data in enumerate(valid_loader()):\n",
    "            # 调整输入数据形状和类型\n",
    "            x_data = np.array([item[0] for item in data], dtype='float32').reshape(-1, 1, 28, 28)\n",
    "            y_data = np.array([item[1] for item in data], dtype='int64').reshape(-1, 1)\n",
    "            # 将numpy.ndarray转化成Tensor\n",
    "            img = fluid.dygraph.to_variable(x_data)\n",
    "            label = fluid.dygraph.to_variable(y_data)\n",
    "            # 计算模型输出\n",
    "            logits = model(img)\n",
    "            pred = fluid.layers.softmax(logits)\n",
    "            # 计算损失函数\n",
    "            loss = fluid.layers.softmax_with_cross_entropy(logits, label)\n",
    "            acc = fluid.layers.accuracy(pred, label)\n",
    "            accuracies.append(acc.numpy())\n",
    "            losses.append(loss.numpy())\n",
    "        print(\"[validation] accuracy/loss: {}/{}\".format(np.mean(accuracies), np.mean(losses)))\n",
    "        model.train()\n",
    "\n",
    "    # 保存模型参数\n",
    "    fluid.save_dygraph(model.state_dict(), 'mnist')\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    # 创建模型\n",
    "    with fluid.dygraph.guard():\n",
    "        model = LeNet(\"LeNet\", num_classes=10)\n",
    "        #启动训练过程\n",
    "        train(model)\n",
    " \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "通过运行结果可以看出，LeNet在手写数字识别MNIST验证数据集上的准确率高达92%以上。那么对于其它数据集效果如何呢？我们通过眼疾识别数据集iChallenge-PM验证一下。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## LeNet在眼疾识别数据集iChallenge-PM上的应用\n",
    "\n",
    "[iChallenge-PM](https://ai.baidu.com/broad/introduction)是百度大脑和中山大学中山眼科中心联合举办的iChallenge比赛中，提供的关于病理性近视（Pathologic Myopia，PM）的医疗类数据集，包含1200个受试者的眼底视网膜图片，训练、验证和测试数据集各400张。下面我们详细介绍LeNet在iChallenge-PM上的训练过程。\n",
    "\n",
    "------\n",
    "**说明：**\n",
    "\n",
    "如今近视已经成为困扰人们健康的一项全球性负担，在近视人群中，有超过35%的人患有重度近视。近似将会导致眼睛的光轴被拉长，有可能引起视网膜或者络网膜的病变。随着近似度数的不断加深，高度近似有可能引发病理性病变，这将会导致以下几种症状：视网膜或者络网膜发生退化、视盘区域萎缩、漆裂样纹损害、Fuchs斑等。因此，及早发现近似患者眼睛的病变并采取治疗，显得非常重要。\n",
    "\n",
    "数据可以从AIStudio[下载](https://aistudio.baidu.com/aistudio/datasetdetail/19065)\n",
    "\n",
    "------\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### 数据集准备\n",
    "\n",
    "/home/aistudio/data/data19065 目录包括如下三个文件，解压缩后存放在/home/aistudio/work/palm目录下。\n",
    "- training.zip：包含训练中的图片和标签\n",
    "- validation.zip：包含验证集的图片\n",
    "- valid_gt.zip：包含验证集的标签\n",
    "\n",
    "------\n",
    "**注意**：\n",
    "\n",
    "valid_gt.zip文件解压缩之后，需要将/home/aistudio/work/palm/PALM-Validation-GT/目录下的PM_Label_and_Fovea_Location.xlsx文件转存成csv格式，本节代码示例中已经提前转成文件labels.csv。\n",
    "\n",
    "------"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# 初次运行时将注释取消，以便解压文件\n",
    "# 如果已经解压过了，则不需要运行此段代码，否则文件已经存在解压会报错\n",
    "#!unzip -d /home/aistudio/work/palm /home/aistudio/data/data19065/training.zip\n",
    "#%cd /home/aistudio/work/palm/PALM-Training400/\n",
    "#!unzip PALM-Training400.zip\n",
    "#!unzip -d /home/aistudio/work/palm /home/aistudio/data/data19065/validation.zip\n",
    "#!unzip -d /home/aistudio/work/palm /home/aistudio/data/data19065/valid_gt.zip\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### 查看数据集图片\n",
    "\n",
    "iChallenge-PM中既有病理性近视患者的眼底图片，也有非病理性近视患者的图片，命名规则如下：\n",
    "\n",
    "- 病理性近视（PM）：文件名以P开头\n",
    "\n",
    "- 非病理性近视（non-PM）：\n",
    "\n",
    "  * 高度近似（high myopia）：文件名以H开头\n",
    "  \n",
    "  * 正常眼睛（normal）：文件名以N开头\n",
    "\n",
    "我们将病理性患者的图片作为正样本，标签为1； 非病理性患者的图片作为负样本，标签为0。从数据集中选取两张图片，通过LeNet提取特征，构建分类器，对正负样本进行分类，并将图片显示出来。代码如下所示："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x576 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import os\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "from PIL import Image\n",
    "\n",
    "DATADIR = '/home/aistudio/work/palm/PALM-Training400/PALM-Training400'\n",
    "# 文件名以N开头的是正常眼底图片，以P开头的是病变眼底图片\n",
    "file1 = 'N0012.jpg'\n",
    "file2 = 'P0095.jpg'\n",
    "\n",
    "# 读取图片\n",
    "img1 = Image.open(os.path.join(DATADIR, file1))\n",
    "img1 = np.array(img1)\n",
    "img2 = Image.open(os.path.join(DATADIR, file2))\n",
    "img2 = np.array(img2)\n",
    "\n",
    "# 画出读取的图片\n",
    "plt.figure(figsize=(16, 8))\n",
    "f = plt.subplot(121)\n",
    "f.set_title('Normal', fontsize=20)\n",
    "plt.imshow(img1)\n",
    "f = plt.subplot(122)\n",
    "f.set_title('PM', fontsize=20)\n",
    "plt.imshow(img2)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((2056, 2124, 3), (2056, 2124, 3))"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 查看图片形状\n",
    "img1.shape, img2.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### 定义数据读取器\n",
    "\n",
    "使用OpenCV从磁盘读入图片，将每张图缩放到$224\\times224$大小，并且将像素值调整到$[-1, 1]$之间，代码如下所示："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import cv2\n",
    "import random\n",
    "import numpy as np\n",
    "\n",
    "# 对读入的图像数据进行预处理\n",
    "def transform_img(img):\n",
    "    # 将图片尺寸缩放道 224x224\n",
    "    img = cv2.resize(img, (224, 224))\n",
    "    # 读入的图像数据格式是[H, W, C]\n",
    "    # 使用转置操作将其变成[C, H, W]\n",
    "    img = np.transpose(img, (2,0,1))\n",
    "    img = img.astype('float32')\n",
    "    # 将数据范围调整到[-1.0, 1.0]之间\n",
    "    img = img / 255.\n",
    "    img = img * 2.0 - 1.0\n",
    "    return img\n",
    "\n",
    "# 定义训练集数据读取器\n",
    "def data_loader(datadir, batch_size=10, mode = 'train'):\n",
    "    # 将datadir目录下的文件列出来，每条文件都要读入\n",
    "    filenames = os.listdir(datadir)\n",
    "    def reader():\n",
    "        if mode == 'train':\n",
    "            # 训练时随机打乱数据顺序\n",
    "            random.shuffle(filenames)\n",
    "        batch_imgs = []\n",
    "        batch_labels = []\n",
    "        for name in filenames:\n",
    "            filepath = os.path.join(datadir, name)\n",
    "            img = cv2.imread(filepath)\n",
    "            img = transform_img(img)\n",
    "            if name[0] == 'H' or name[0] == 'N':\n",
    "                # H开头的文件名表示高度近似，N开头的文件名表示正常视力\n",
    "                # 高度近视和正常视力的样本，都不是病理性的，属于负样本，标签为0\n",
    "                label = 0\n",
    "            elif name[0] == 'P':\n",
    "                # P开头的是病理性近视，属于正样本，标签为1\n",
    "                label = 1\n",
    "            else:\n",
    "                raise('Not excepted file name')\n",
    "            # 每读取一个样本的数据，就将其放入数据列表中\n",
    "            batch_imgs.append(img)\n",
    "            batch_labels.append(label)\n",
    "            if len(batch_imgs) == batch_size:\n",
    "                # 当数据列表的长度等于batch_size的时候，\n",
    "                # 把这些数据当作一个mini-batch，并作为数据生成器的一个输出\n",
    "                imgs_array = np.array(batch_imgs).astype('float32')\n",
    "                labels_array = np.array(batch_labels).astype('float32').reshape(-1, 1)\n",
    "                yield imgs_array, labels_array\n",
    "                batch_imgs = []\n",
    "                batch_labels = []\n",
    "\n",
    "        if len(batch_imgs) > 0:\n",
    "            # 剩余样本数目不足一个batch_size的数据，一起打包成一个mini-batch\n",
    "            imgs_array = np.array(batch_imgs).astype('float32')\n",
    "            labels_array = np.array(batch_labels).astype('float32').reshape(-1, 1)\n",
    "            yield imgs_array, labels_array\n",
    "\n",
    "    return reader\n",
    "\n",
    "# 定义验证集数据读取器\n",
    "def valid_data_loader(datadir, csvfile, batch_size=10, mode='valid'):\n",
    "    # 训练集读取时通过文件名来确定样本标签，验证集则通过csvfile来读取每个图片对应的标签\n",
    "    # 请查看解压后的验证集标签数据，观察csvfile文件里面所包含的内容\n",
    "    # csvfile文件所包含的内容格式如下，每一行代表一个样本，\n",
    "    # 其中第一列是图片id，第二列是文件名，第三列是图片标签，\n",
    "    # 第四列和第五列是Fovea的坐标，与分类任务无关\n",
    "    # ID,imgName,Label,Fovea_X,Fovea_Y\n",
    "    # 1,V0001.jpg,0,1157.74,1019.87\n",
    "    # 2,V0002.jpg,1,1285.82,1080.47\n",
    "    # 打开包含验证集标签的csvfile，并读入其中的内容\n",
    "    filelists = open(csvfile).readlines()\n",
    "    def reader():\n",
    "        batch_imgs = []\n",
    "        batch_labels = []\n",
    "        for line in filelists[1:]:\n",
    "            line = line.strip().split(',')\n",
    "            name = line[1]\n",
    "            label = int(line[2])\n",
    "            # 根据图片文件名加载图片，并对图像数据作预处理\n",
    "            filepath = os.path.join(datadir, name)\n",
    "            img = cv2.imread(filepath)\n",
    "            img = transform_img(img)\n",
    "            # 每读取一个样本的数据，就将其放入数据列表中\n",
    "            batch_imgs.append(img)\n",
    "            batch_labels.append(label)\n",
    "            if len(batch_imgs) == batch_size:\n",
    "                # 当数据列表的长度等于batch_size的时候，\n",
    "                # 把这些数据当作一个mini-batch，并作为数据生成器的一个输出\n",
    "                imgs_array = np.array(batch_imgs).astype('float32')\n",
    "                labels_array = np.array(batch_labels).astype('float32').reshape(-1, 1)\n",
    "                yield imgs_array, labels_array\n",
    "                batch_imgs = []\n",
    "                batch_labels = []\n",
    "\n",
    "        if len(batch_imgs) > 0:\n",
    "            # 剩余样本数目不足一个batch_size的数据，一起打包成一个mini-batch\n",
    "            imgs_array = np.array(batch_imgs).astype('float32')\n",
    "            labels_array = np.array(batch_labels).astype('float32').reshape(-1, 1)\n",
    "            yield imgs_array, labels_array\n",
    "\n",
    "    return reader\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((10, 3, 224, 224), (10, 1))"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 查看数据形状\n",
    "DATADIR = '/home/aistudio/work/palm/PALM-Training400/PALM-Training400'\n",
    "train_loader = data_loader(DATADIR, \n",
    "                           batch_size=10, mode='train')\n",
    "data_reader = train_loader()\n",
    "data = next(data_reader)\n",
    "data[0].shape, data[1].shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "#### 启动训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "start training ... \n",
      "epoch: 0, batch_id: 0, loss is: [0.7190998]\n"
     ]
    }
   ],
   "source": [
    "# -*- coding: utf-8 -*-\n",
    "\n",
    "# LeNet 识别眼疾图片\n",
    "\n",
    "import os\n",
    "import random\n",
    "import paddle\n",
    "import paddle.fluid as fluid\n",
    "import numpy as np\n",
    "\n",
    "DATADIR = '/home/aistudio/work/palm/PALM-Training400/PALM-Training400'\n",
    "DATADIR2 = '/home/aistudio/work/palm/PALM-Validation400'\n",
    "CSVFILE = '/home/aistudio/work/palm/PALM-Validation-GT/labels.csv'\n",
    "\n",
    "# 定义训练过程\n",
    "def train(model):\n",
    "    with fluid.dygraph.guard():\n",
    "        print('start training ... ')\n",
    "        model.train()\n",
    "        epoch_num = 5\n",
    "        # 定义优化器\n",
    "        opt = fluid.optimizer.Momentum(learning_rate=0.001, momentum=0.9)\n",
    "        # 定义数据读取器，训练数据读取器和验证数据读取器\n",
    "        train_loader = data_loader(DATADIR, batch_size=10, mode='train')\n",
    "        valid_loader = valid_data_loader(DATADIR2, CSVFILE)\n",
    "        for epoch in range(epoch_num):\n",
    "            for batch_id, data in enumerate(train_loader()):\n",
    "                x_data, y_data = data\n",
    "                img = fluid.dygraph.to_variable(x_data)\n",
    "                label = fluid.dygraph.to_variable(y_data)\n",
    "                # 运行模型前向计算，得到预测值\n",
    "                logits = model(img)\n",
    "                # 进行loss计算\n",
    "                loss = fluid.layers.sigmoid_cross_entropy_with_logits(logits, label)\n",
    "                avg_loss = fluid.layers.mean(loss)\n",
    "\n",
    "                if batch_id % 10 == 0:\n",
    "                    print(\"epoch: {}, batch_id: {}, loss is: {}\".format(epoch, batch_id, avg_loss.numpy()))\n",
    "                # 反向传播，更新权重，清除梯度\n",
    "                avg_loss.backward()\n",
    "                opt.minimize(avg_loss)\n",
    "                model.clear_gradients()\n",
    "\n",
    "            model.eval()\n",
    "            accuracies = []\n",
    "            losses = []\n",
    "            for batch_id, data in enumerate(valid_loader()):\n",
    "                x_data, y_data = data\n",
    "                img = fluid.dygraph.to_variable(x_data)\n",
    "                label = fluid.dygraph.to_variable(y_data)\n",
    "                # 运行模型前向计算，得到预测值\n",
    "                logits = model(img)\n",
    "                # 二分类，sigmoid计算后的结果以0.5为阈值分两个类别\n",
    "                # 计算sigmoid后的预测概率，进行loss计算\n",
    "                pred = fluid.layers.sigmoid(logits)\n",
    "                loss = fluid.layers.sigmoid_cross_entropy_with_logits(logits, label)\n",
    "                # 计算预测概率小于0.5的类别\n",
    "                pred2 = pred * (-1.0) + 1.0\n",
    "                # 得到两个类别的预测概率，并沿第一个维度级联\n",
    "                pred = fluid.layers.concat([pred2, pred], axis=1)\n",
    "                acc = fluid.layers.accuracy(pred, fluid.layers.cast(label, dtype='int64'))\n",
    "                accuracies.append(acc.numpy())\n",
    "                losses.append(loss.numpy())\n",
    "            print(\"[validation] accuracy/loss: {}/{}\".format(np.mean(accuracies), np.mean(losses)))\n",
    "            model.train()\n",
    "\n",
    "        # save params of model\n",
    "        fluid.save_dygraph(model.state_dict(), 'mnist')\n",
    "        # save optimizer state\n",
    "        fluid.save_dygraph(opt.state_dict(), 'mnist')\n",
    "\n",
    "\n",
    "# 定义评估过程\n",
    "def evaluation(model, params_file_path):\n",
    "    with fluid.dygraph.guard():\n",
    "        print('start evaluation .......')\n",
    "        #加载模型参数\n",
    "        model_state_dict, _ = fluid.load_dygraph(params_file_path)\n",
    "        model.load_dict(model_state_dict)\n",
    "\n",
    "        model.eval()\n",
    "        eval_loader = load_data('eval')\n",
    "\n",
    "        acc_set = []\n",
    "        avg_loss_set = []\n",
    "        for batch_id, data in enumerate(eval_loader()):\n",
    "            x_data, y_data = data\n",
    "            img = fluid.dygraph.to_variable(x_data)\n",
    "            label = fluid.dygraph.to_variable(y_data)\n",
    "            # 计算预测和精度\n",
    "            prediction, acc = model(img, label)\n",
    "            # 计算损失函数值\n",
    "            loss = fluid.layers.cross_entropy(input=prediction, label=label)\n",
    "            avg_loss = fluid.layers.mean(loss)\n",
    "            acc_set.append(float(acc.numpy()))\n",
    "            avg_loss_set.append(float(avg_loss.numpy()))\n",
    "        # 求平均精度\n",
    "        acc_val_mean = np.array(acc_set).mean()\n",
    "        avg_loss_val_mean = np.array(avg_loss_set).mean()\n",
    "\n",
    "        print('loss={}, acc={}'.format(avg_loss_val_mean, acc_val_mean))\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    # 创建模型\n",
    "    with fluid.dygraph.guard():\n",
    "        model = LeNet(\"LeNet\", num_classes=1)\n",
    "\n",
    "    train(model)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "通过运行结果可以看出，在眼疾筛查数据集iChallenge-PM上，LeNet的loss很难下降，模型没有收敛。这是因为MNIST数据集的图片尺寸比较小（$28\\times28$），但是眼疾筛查数据集图片尺寸比较大（原始图片尺寸约为$2000 \\times 2000$，经过缩放之后变成$224 \\times 224$），LeNet模型很难进行有效分类。这说明在图片尺寸比较大时，LeNet在图像分类任务上存在局限性。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## AlexNet\n",
    "\n",
    "\n",
    "通过上面的实际训练可以看到，虽然LeNet在手写数字识别数据集上取得了很好的结果，但在更大的数据集上表现却并不好。自从1998年LeNet问世以来，接下来十几年的时间里，神经网络并没有在计算机视觉领域取得很好的结果，反而一度被其它算法所超越，原因主要有两方面，一是神经网络的计算比较复杂，对当时计算机的算力来说，训练神经网络是件非常耗时的事情；另一方面，当时还没有专门针对神经网络做算法和训练技巧的优化，神经网络的收敛性是件非常困难的事情。\n",
    "\n",
    "随着技术的进步和发展，计算机的算力越来越强大，尤其是在GPU并行计算能力的推动下，复杂神经网络的计算也变得更加容易实施。另一方面，互联网上涌现出越来越多的数据，极大的丰富了数据库。同时也有越来越多的研究人员开始专门针对神经网络做算法和模型的优化，Alex Krizhevsky等人提出的AlexNet以很大优势获得了2012年ImageNet比赛的冠军。这一成果极大的激发了业界对神经网络的兴趣，开创了使用深度神经网络解决图像问题的途径，随后也在这一领域涌现出越来越多的优秀工作。\n",
    "\n",
    "AlexNet与LeNet相比，具有更深的网络结构，包含5层卷积和3层全连接，同时使用了如下三种方法改进模型的训练过程：\n",
    "\n",
    "  - 数据增多：深度学习中常用的一种处理方式，通过对训练随机加一些变化，比如平移、缩放、裁剪、旋转、翻转或者增减亮度等，产生一系列跟原始图片相似但又不完全相同的样本，从而扩大训练数据集。通过这种方式，可以随机改变训练样本，避免模型过度依赖于某些属性，能从一定程度上抑制过拟合。\n",
    "  \n",
    "  - 使用Dropout抑制过拟合\n",
    "  \n",
    "  - 使用ReLU激活函数少梯度消失现象\n",
    "  \n",
    "\n",
    "------\n",
    "**说明：**\n",
    "\n",
    "下一节详细介绍数据增多的具体实现方式。\n",
    "\n",
    "-------\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "AlexNet的具体结构如 **图2** 所示：\n",
    "\n",
    "<br></br>\n",
    "<center><img src=\"https://ai-studio-static-online.cdn.bcebos.com/d28eb5b9ad2c458a9922e528312486eb994529fdfabd4a9488c33746a3e1dac7\" width = \"700\"></center>\n",
    "<center><br>图2：AlexNet模型网络结构示意图</br></center>\n",
    "<br></br>\n",
    "\n",
    "AlexNet在眼疾筛查数据集iChallenge-PM上具体实现的代码如下所示："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# -*- coding:utf-8 -*-\n",
    "\n",
    "# 导入需要的包\n",
    "import paddle\n",
    "import paddle.fluid as fluid\n",
    "import numpy as np\n",
    "from paddle.fluid.dygraph.nn import Conv2D, Pool2D, FC\n",
    "\n",
    "\n",
    "# 定义 AlexNet 网络结构\n",
    "class AlexNet(fluid.dygraph.Layer):\n",
    "    def __init__(self, name_scope, num_classes=1):\n",
    "        super(AlexNet, self).__init__(name_scope)\n",
    "        name_scope = self.full_name()\n",
    "        # AlexNet与LeNet一样也会同时使用卷积和池化层提取图像特征\n",
    "        # 与LeNet不同的是激活函数换成了‘relu’\n",
    "        self.conv1 = Conv2D(name_scope, num_filters=96, filter_size=11, stride=4, padding=5, act='relu')\n",
    "        self.pool1 = Pool2D(name_scope, pool_size=2, pool_stride=2, pool_type='max')\n",
    "        self.conv2 = Conv2D(name_scope, num_filters=256, filter_size=5, stride=1, padding=2, act='relu')\n",
    "        self.pool2 = Pool2D(name_scope, pool_size=2, pool_stride=2, pool_type='max')\n",
    "        self.conv3 = Conv2D(name_scope, num_filters=384, filter_size=3, stride=1, padding=1, act='relu')\n",
    "        self.conv4 = Conv2D(name_scope, num_filters=384, filter_size=3, stride=1, padding=1, act='relu')\n",
    "        self.conv5 = Conv2D(name_scope, num_filters=256, filter_size=3, stride=1, padding=1, act='relu')\n",
    "        self.pool5 = Pool2D(name_scope, pool_size=2, pool_stride=2, pool_type='max')\n",
    "\n",
    "        self.fc1 = FC(name_scope, size=4096, act='relu')\n",
    "        self.drop_ratio1 = 0.5\n",
    "        self.fc2 = FC(name_scope, size=4096, act='relu')\n",
    "        self.drop_ratio2 = 0.5\n",
    "        self.fc3 = FC(name_scope, size=num_classes)\n",
    "\n",
    "        \n",
    "    def forward(self, x):\n",
    "        x = self.conv1(x)\n",
    "        x = self.pool1(x)\n",
    "        x = self.conv2(x)\n",
    "        x = self.pool2(x)\n",
    "        x = self.conv3(x)\n",
    "        x = self.conv4(x)\n",
    "        x = self.conv5(x)\n",
    "        x = self.pool5(x)\n",
    "\n",
    "        x = self.fc1(x)\n",
    "        # 在全连接之后使用dropout抑制过拟合\n",
    "        x= fluid.layers.dropout(x, self.drop_ratio1)\n",
    "        x = self.fc2(x)\n",
    "        # 在全连接之后使用dropout抑制过拟合\n",
    "        x = fluid.layers.dropout(x, self.drop_ratio2)\n",
    "        x = self.fc3(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "start training ... \n",
      "epoch: 0, batch_id: 0, loss is: [0.85222495]\n"
     ]
    }
   ],
   "source": [
    "with fluid.dygraph.guard():\n",
    "    model = AlexNet(\"AlexNet\")\n",
    "\n",
    "train(model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "通过运行结果可以发现，在眼疾筛查数据集iChallenge-PM上使用AlexNet，loss能有效下降，经过5个epoch的训练，在验证集上的准确率可以达到94%左右。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## VGG\n",
    "\n",
    "VGG是当前最流行的CNN模型之一，2014年由Simonyan和Zisserman提出，其命名来源于论文作者所在的实验室Visual Geometry Group。AlexNet模型通过构造多层网络，取得了较好的效果，但是并没有给出深度神经网络设计的方向。VGG通过使用一系列大小为3x3的小尺寸卷积核和pooling层构造深度卷积神经网络，并取得了较好的效果。VGG模型因为结构简单、应用性极强而广受研究者欢迎，尤其是它的网络结构设计方法，为构建深度神经网络提供了方向。\n",
    "\n",
    "**图3** 是VGG-16的网络结构示意图，有13层卷积和3层全连接层。VGG网络的设计严格使用$3\\times 3$的卷积层和池化层来提取特征，并在网络的最后面使用三层全连接层，将最后一层全连接层的输出作为分类的预测。\n",
    "在VGG中每层卷积将使用ReLU作为激活函数，在全连接层之后添加dropout来抑制过拟合。使用小的卷积核能够有效地减少参数的个数，使得训练和测试变得更加有效。比如使用两层$3\\times 3$卷积层，可以得到感受野为5的特征图，而比使用$5 \\times 5$的卷积层需要更少的参数。由于卷积核比较小，可以堆叠更多的卷积层，加深网络的深度，这对于图像分类任务来说是有利的。VGG模型的成功证明了增加网络的深度，可以更好的学习图像中的特征模式。\n",
    "\n",
    "<br></br>\n",
    "<center><img src=\"https://ai-studio-static-online.cdn.bcebos.com/f22dc04130f24933865fbd82e61fb8e2e15849dc4a2e411ea785dea239de6cfe\" width = \"700\"></center>\n",
    "<center><br>图3：VGG模型网络结构示意图</br></center>\n",
    "<br></br>\n",
    "\n",
    "VGG在眼疾识别数据集iChallenge-PM上的具体实现如下代码所示："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# -*- coding:utf-8 -*-\n",
    "\n",
    "# VGG模型代码\n",
    "import numpy as np\n",
    "import paddle\n",
    "import paddle.fluid as fluid\n",
    "from paddle.fluid.layer_helper import LayerHelper\n",
    "from paddle.fluid.dygraph.nn import Conv2D, Pool2D, BatchNorm, FC\n",
    "from paddle.fluid.dygraph.base import to_variable\n",
    "\n",
    "# 定义vgg块，包含多层卷积和1层2x2的最大池化层\n",
    "class vgg_block(fluid.dygraph.Layer):\n",
    "    def __init__(self, name_scope, num_convs, num_channels):\n",
    "        \"\"\"\n",
    "        num_convs, 卷积层的数目\n",
    "        num_channels, 卷积层的输出通道数，在同一个Incepition块内，卷积层输出通道数是一样的\n",
    "        \"\"\"\n",
    "        super(vgg_block, self).__init__(name_scope)\n",
    "        self.conv_list = []\n",
    "        for i in range(num_convs):\n",
    "            conv_layer = self.add_sublayer('conv_' + str(i), Conv2D(self.full_name(), \n",
    "                                        num_filters=num_channels, filter_size=3, padding=1, act='relu'))\n",
    "            self.conv_list.append(conv_layer)\n",
    "        self.pool = Pool2D(self.full_name(), pool_stride=2, pool_size = 2, pool_type='max')\n",
    "    def forward(self, x):\n",
    "        for item in self.conv_list:\n",
    "            x = item(x)\n",
    "        return self.pool(x)\n",
    "\n",
    "class VGG(fluid.dygraph.Layer):\n",
    "    def __init__(self, name_scope, conv_arch=((2, 64), \n",
    "                                (2, 128), (3, 256), (3, 512), (3, 512))):\n",
    "        super(VGG, self).__init__(name_scope)\n",
    "        self.vgg_blocks=[]\n",
    "        iter_id = 0\n",
    "        # 添加vgg_block\n",
    "        # 这里一共5个vgg_block，每个block里面的卷积层数目和输出通道数由conv_arch指定\n",
    "        for (num_convs, num_channels) in conv_arch:\n",
    "            block = self.add_sublayer('block_' + str(iter_id), \n",
    "                    vgg_block(self.full_name(), num_convs, num_channels))\n",
    "            self.vgg_blocks.append(block)\n",
    "            iter_id += 1\n",
    "        self.fc1 = FC(self.full_name(),\n",
    "                      size=4096,\n",
    "                      act='relu')\n",
    "        self.drop1_ratio = 0.5\n",
    "        self.fc2= FC(self.full_name(),\n",
    "                      size=4096,\n",
    "                      act='relu')\n",
    "        self.drop2_ratio = 0.5\n",
    "        self.fc3 = FC(self.full_name(),\n",
    "                      size=1,\n",
    "                      )\n",
    "    def forward(self, x):\n",
    "        for item in self.vgg_blocks:\n",
    "            x = item(x)\n",
    "        x = fluid.layers.dropout(self.fc1(x), self.drop1_ratio)\n",
    "        x = fluid.layers.dropout(self.fc2(x), self.drop2_ratio)\n",
    "        x = self.fc3(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "start training ... \n",
      "epoch: 0, batch_id: 0, loss is: [0.70688695]\n",
      "epoch: 0, batch_id: 10, loss is: [0.6499025]\n",
      "epoch: 0, batch_id: 20, loss is: [0.5425986]\n",
      "epoch: 0, batch_id: 30, loss is: [0.50737983]\n",
      "[validation] accuracy/loss: 0.9225000143051147/0.303012877702713\n",
      "epoch: 1, batch_id: 0, loss is: [0.22892232]\n",
      "epoch: 1, batch_id: 10, loss is: [0.18709533]\n",
      "epoch: 1, batch_id: 20, loss is: [0.47961444]\n",
      "epoch: 1, batch_id: 30, loss is: [0.2862179]\n",
      "[validation] accuracy/loss: 0.925000011920929/0.26821640133857727\n",
      "epoch: 2, batch_id: 0, loss is: [0.44708306]\n",
      "epoch: 2, batch_id: 10, loss is: [0.25814787]\n",
      "epoch: 2, batch_id: 20, loss is: [1.0395074]\n",
      "epoch: 2, batch_id: 30, loss is: [0.15475456]\n",
      "[validation] accuracy/loss: 0.9200000762939453/0.24057604372501373\n",
      "epoch: 3, batch_id: 0, loss is: [0.2680076]\n",
      "epoch: 3, batch_id: 10, loss is: [0.34904015]\n",
      "epoch: 3, batch_id: 20, loss is: [0.50666857]\n",
      "epoch: 3, batch_id: 30, loss is: [0.30491194]\n",
      "[validation] accuracy/loss: 0.9200000762939453/0.2539993226528168\n",
      "epoch: 4, batch_id: 0, loss is: [0.32648644]\n",
      "epoch: 4, batch_id: 10, loss is: [0.07601605]\n",
      "epoch: 4, batch_id: 20, loss is: [0.4142092]\n",
      "epoch: 4, batch_id: 30, loss is: [0.10387868]\n",
      "[validation] accuracy/loss: 0.940000057220459/0.1902739703655243\n"
     ]
    }
   ],
   "source": [
    "with fluid.dygraph.guard():\n",
    "    model = VGG(\"VGG\")\n",
    "\n",
    "train(model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "通过运行结果可以发现，在眼疾筛查数据集iChallenge-PM上使用VGG，loss能有效的下降，经过5个epoch的训练，在验证集上的准确率可以达到94%左右。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## GoogLeNet\n",
    "\n",
    "GoogLeNet是2014年ImageNet比赛的冠军，它的主要特点是网络不仅有深度，还在横向上具有“宽度”。由于图像信息在空间尺寸上的巨大差异，如何选择合适的卷积核大小来提取特征就显得比较困难了。空间分布范围更广的图像信息适合用较大的卷积核来提取其特征，而空间分布范围较小的图像信息则适合用较小的卷积核来提取其特征。为了解决这个问题，GoogLeNet提出了一种被称为Inception模块的方案。如 **图4** 所示：\n",
    "\n",
    "------\n",
    "**说明：**\n",
    "\n",
    "- Google的研究人员为了向LeNet致敬，特地将模型命名为GoogLeNet\n",
    "- Inception一词来源于电影《盗梦空间》（Inception）\n",
    "------\n",
    "<br></br>\n",
    "<center><img src=\"https://ai-studio-static-online.cdn.bcebos.com/96f92806a70446e880d87bad5f7b7d8936c36abcb1ff4fcd9c3391ae5fca902d\" width = \"700\"></center>\n",
    "<center><br>图4：Inception模块结构示意图</br></center>\n",
    "<br></br>\n",
    "图4(a)是Inception模块的设计思想，使用3个不同大小的卷积核对输入图片进行卷积操作，并附加最大池化，将这4个操作的输出沿着通道这一维度进行拼接，构成的输出特征图将会包含经过不同大小的卷积核提取出来的特征。Inception模块采用多通路(multi-path)的设计形式，每个支路使用不同大小的卷积核，最终输出特征图的通道数是每个支路输出通道数的总和，这将会导致输出通道数变得很大，尤其是使用多个Inception模块串联操作的时候，模型参数量会变得非常巨大。为了减小参数量，Inception模块使用了图(b)中的设计方式，在每个3x3和5x5的卷积层之前，增加1x1的卷积层来控制输出通道数；在最大池化层后面增加1x1卷积层减小输出通道数。基于这一设计思想，形成了上图(b)中所示的结构。下面这段程序是Inception块的具体实现方式，可以对照图(b)和代码一起阅读。\n",
    "\n",
    "------\n",
    "**提示：**\n",
    "\n",
    "可能有读者会问，经过3x3的最大池化之后图像尺寸不会减小吗，为什么还能跟另外3个卷积输出的特征图进行拼接？这是因为池化操作可以指定窗口大小$k_h = K_w = 3$，pool_stride=1和pool_padding=1，输出特征图尺寸可以保持不变。\n",
    "\n",
    "------\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "Inception模块的具体实现如下代码所示："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "class Inception(fluid.dygraph.Layer):\n",
    "    def __init__(self, name_scope, c1, c2, c3, c4, **kwargs):\n",
    "        '''\n",
    "        Inception模块的实现代码，\n",
    "        name_scope, 模块名称，数据类型为string\n",
    "        c1,  图(b)中第一条支路1x1卷积的输出通道数，数据类型是整数\n",
    "        c2，图(b)中第二条支路卷积的输出通道数，数据类型是tuple或list, \n",
    "               其中c2[0]是1x1卷积的输出通道数，c2[1]是3x3\n",
    "        c3，图(b)中第三条支路卷积的输出通道数，数据类型是tuple或list, \n",
    "               其中c3[0]是1x1卷积的输出通道数，c3[1]是3x3\n",
    "        c4,  图(b)中第一条支路1x1卷积的输出通道数，数据类型是整数\n",
    "        '''\n",
    "        super(Inception, self).__init__(name_scope)\n",
    "        # 依次创建Inception块每条支路上使用到的操作\n",
    "        self.p1_1 = Conv2D(self.full_name(), num_filters=c1, \n",
    "                           filter_size=1, act='relu')\n",
    "        self.p2_1 = Conv2D(self.full_name(), num_filters=c2[0], \n",
    "                           filter_size=1, act='relu')\n",
    "        self.p2_2 = Conv2D(self.full_name(), num_filters=c2[1], \n",
    "                           filter_size=3, padding=1, act='relu')\n",
    "        self.p3_1 = Conv2D(self.full_name(), num_filters=c3[0], \n",
    "                           filter_size=1, act='relu')\n",
    "        self.p3_2 = Conv2D(self.full_name(), num_filters=c3[1], \n",
    "                           filter_size=5, padding=2, act='relu')\n",
    "        self.p4_1 = Pool2D(self.full_name(), pool_size=3, \n",
    "                           pool_stride=1,  pool_padding=1, \n",
    "                           pool_type='max')\n",
    "        self.p4_2 = Conv2D(self.full_name(), num_filters=c4, \n",
    "                           filter_size=1, act='relu')\n",
    "\n",
    "    def forward(self, x):\n",
    "        # 支路1只包含一个1x1卷积\n",
    "        p1 = self.p1_1(x)\n",
    "        # 支路2包含 1x1卷积 + 3x3卷积\n",
    "        p2 = self.p2_2(self.p2_1(x))\n",
    "        # 支路3包含 1x1卷积 + 5x5卷积\n",
    "        p3 = self.p3_2(self.p3_1(x))\n",
    "        # 支路4包含 最大池化和1x1卷积\n",
    "        p4 = self.p4_2(self.p4_1(x))\n",
    "        # 将每个支路的输出特征图拼接在一起作为最终的输出结果\n",
    "        return fluid.layers.concat([p1, p2, p3, p4], axis=1)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "GoogLeNet的架构如 **图5** 所示，在主体卷积部分中使用5个模块（block），每个模块之间使用步幅为2的3 ×3最大池化层来减小输出高宽。\n",
    "* 第一模块使用一个64通道的7 × 7卷积层。\n",
    "* 第二模块使用2个卷积层:首先是64通道的1 × 1卷积层，然后是将通道增大3倍的3 × 3卷积层。\n",
    "* 第三模块串联2个完整的Inception块。\n",
    "* 第四模块串联了5个Inception块。\n",
    "* 第五模块串联了2 个Inception块。\n",
    "* 第五模块的后面紧跟输出层，使用全局平均池化 层来将每个通道的高和宽变成1，最后接上一个输出个数为标签类别数的全连接层。\n",
    "\n",
    "-----\n",
    "说明：\n",
    "在原作者的论文中添加了图中所示的softmax1和softmax2两个辅助分类器，如下图所示，训练时将三个分类器的损失函数进行加权求和，以缓解梯度消失现象。这里的程序作了简化，没有加入辅助分类器。\n",
    "\n",
    "-----\n",
    "\n",
    "\n",
    "<br></br>\n",
    "<center><img src=\"https://ai-studio-static-online.cdn.bcebos.com/fcc73767fc944464aa37c4d1112cadab90f5856a0afc49eeaa12db61c9762d0f\" width = \"600\"></center>\n",
    "<center><br>图5：GoogLeNet模型网络结构示意图</br></center>\n",
    "<br></br>\n",
    "\n",
    "GoogLeNet的具体实现如下代码所示："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# -*- coding:utf-8 -*-\n",
    "\n",
    "# GoogLeNet模型代码\n",
    "import numpy as np\n",
    "import paddle\n",
    "import paddle.fluid as fluid\n",
    "from paddle.fluid.layer_helper import LayerHelper\n",
    "from paddle.fluid.dygraph.nn import Conv2D, Pool2D, BatchNorm, FC\n",
    "from paddle.fluid.dygraph.base import to_variable\n",
    "\n",
    "# 定义Inception块\n",
    "class Inception(fluid.dygraph.Layer):\n",
    "    def __init__(self, name_scope, c1, c2, c3, c4, **kwargs):\n",
    "        '''\n",
    "        Inception模块的实现代码，\n",
    "        name_scope, 模块名称，数据类型为string\n",
    "        c1,  图(b)中第一条支路1x1卷积的输出通道数，数据类型是整数\n",
    "        c2，图(b)中第二条支路卷积的输出通道数，数据类型是tuple或list, \n",
    "               其中c2[0]是1x1卷积的输出通道数，c2[1]是3x3\n",
    "        c3，图(b)中第三条支路卷积的输出通道数，数据类型是tuple或list, \n",
    "               其中c3[0]是1x1卷积的输出通道数，c3[1]是3x3\n",
    "        c4,  图(b)中第一条支路1x1卷积的输出通道数，数据类型是整数\n",
    "        '''\n",
    "        super(Inception, self).__init__(name_scope)\n",
    "        # 依次创建Inception块每条支路上使用到的操作\n",
    "        self.p1_1 = Conv2D(self.full_name(), num_filters=c1, \n",
    "                           filter_size=1, act='relu')\n",
    "        self.p2_1 = Conv2D(self.full_name(), num_filters=c2[0], \n",
    "                           filter_size=1, act='relu')\n",
    "        self.p2_2 = Conv2D(self.full_name(), num_filters=c2[1], \n",
    "                           filter_size=3, padding=1, act='relu')\n",
    "        self.p3_1 = Conv2D(self.full_name(), num_filters=c3[0], \n",
    "                           filter_size=1, act='relu')\n",
    "        self.p3_2 = Conv2D(self.full_name(), num_filters=c3[1], \n",
    "                           filter_size=5, padding=2, act='relu')\n",
    "        self.p4_1 = Pool2D(self.full_name(), pool_size=3, \n",
    "                           pool_stride=1,  pool_padding=1, \n",
    "                           pool_type='max')\n",
    "        self.p4_2 = Conv2D(self.full_name(), num_filters=c4, \n",
    "                           filter_size=1, act='relu')\n",
    "\n",
    "    def forward(self, x):\n",
    "        # 支路1只包含一个1x1卷积\n",
    "        p1 = self.p1_1(x)\n",
    "        # 支路2包含 1x1卷积 + 3x3卷积\n",
    "        p2 = self.p2_2(self.p2_1(x))\n",
    "        # 支路3包含 1x1卷积 + 5x5卷积\n",
    "        p3 = self.p3_2(self.p3_1(x))\n",
    "        # 支路4包含 最大池化和1x1卷积\n",
    "        p4 = self.p4_2(self.p4_1(x))\n",
    "        # 将每个支路的输出特征图拼接在一起作为最终的输出结果\n",
    "        return fluid.layers.concat([p1, p2, p3, p4], axis=1)  \n",
    "    \n",
    "class GoogLeNet(fluid.dygraph.Layer):\n",
    "    def __init__(self, name_scope):\n",
    "        super(GoogLeNet, self).__init__(name_scope)\n",
    "        # GoogLeNet包含五个模块，每个模块后面紧跟一个池化层\n",
    "        # 第一个模块包含1个卷积层\n",
    "        self.conv1 = Conv2D(self.full_name(), num_filters=64, filter_size=7, \n",
    "                            padding=3, act='relu')\n",
    "        # 3x3最大池化\n",
    "        self.pool1 = Pool2D(self.full_name(), pool_size=3, pool_stride=2,  \n",
    "                            pool_padding=1, pool_type='max')\n",
    "        # 第二个模块包含2个卷积层\n",
    "        self.conv2_1 = Conv2D(self.full_name(), num_filters=64, \n",
    "                              filter_size=1, act='relu')\n",
    "        self.conv2_2 = Conv2D(self.full_name(), num_filters=192, \n",
    "                              filter_size=3, padding=1, act='relu')\n",
    "        # 3x3最大池化\n",
    "        self.pool2 = Pool2D(self.full_name(), pool_size=3, pool_stride=2,  \n",
    "                            pool_padding=1, pool_type='max')\n",
    "        # 第三个模块包含2个Inception块\n",
    "        self.block3_1 = Inception(self.full_name(), 64, (96, 128), (16, 32), 32)\n",
    "        self.block3_2 = Inception(self.full_name(), 128, (128, 192), (32, 96), 64)\n",
    "        # 3x3最大池化\n",
    "        self.pool3 = Pool2D(self.full_name(), pool_size=3, pool_stride=2,  \n",
    "                               pool_padding=1, pool_type='max')\n",
    "        # 第四个模块包含5个Inception块\n",
    "        self.block4_1 = Inception(self.full_name(), 192, (96, 208), (16, 48), 64)\n",
    "        self.block4_2 = Inception(self.full_name(), 160, (112, 224), (24, 64), 64)\n",
    "        self.block4_3 = Inception(self.full_name(), 128, (128, 256), (24, 64), 64)\n",
    "        self.block4_4 = Inception(self.full_name(), 112, (144, 288), (32, 64), 64)\n",
    "        self.block4_5 = Inception(self.full_name(), 256, (160, 320), (32, 128), 128)\n",
    "        # 3x3最大池化\n",
    "        self.pool4 = Pool2D(self.full_name(), pool_size=3, pool_stride=2,  \n",
    "                               pool_padding=1, pool_type='max')\n",
    "        # 第五个模块包含2个Inception块\n",
    "        self.block5_1 = Inception(self.full_name(), 256, (160, 320), (32, 128), 128)\n",
    "        self.block5_2 = Inception(self.full_name(), 384, (192, 384), (48, 128), 128)\n",
    "        # 全局池化，尺寸用的是global_pooling，pool_stride不起作用\n",
    "        self.pool5 = Pool2D(self.full_name(), pool_stride=1, \n",
    "                               global_pooling=True, pool_type='avg')\n",
    "        self.fc = FC(self.full_name(),  size=1)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.pool1(self.conv1(x))\n",
    "        x = self.pool2(self.conv2_2(self.conv2_1(x)))\n",
    "        x = self.pool3(self.block3_2(self.block3_1(x)))\n",
    "        x = self.block4_3(self.block4_2(self.block4_1(x)))\n",
    "        x = self.pool4(self.block4_5(self.block4_4(x)))\n",
    "        x = self.pool5(self.block5_2(self.block5_1(x)))\n",
    "        x = self.fc(x)\n",
    "        return x\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "start training ... \n",
      "epoch: 0, batch_id: 0, loss is: [0.8154737]\n",
      "epoch: 0, batch_id: 10, loss is: [0.91645]\n",
      "epoch: 0, batch_id: 20, loss is: [0.7236319]\n",
      "epoch: 0, batch_id: 30, loss is: [0.68567497]\n",
      "[validation] accuracy/loss: 0.5375000238418579/0.5847560167312622\n",
      "epoch: 1, batch_id: 0, loss is: [0.5989523]\n",
      "epoch: 1, batch_id: 10, loss is: [0.68977153]\n",
      "epoch: 1, batch_id: 20, loss is: [0.49947825]\n",
      "epoch: 1, batch_id: 30, loss is: [0.45672542]\n",
      "[validation] accuracy/loss: 0.6899999976158142/0.49434658885002136\n",
      "epoch: 2, batch_id: 0, loss is: [0.58344376]\n",
      "epoch: 2, batch_id: 10, loss is: [0.18998024]\n",
      "epoch: 2, batch_id: 20, loss is: [0.4772973]\n",
      "epoch: 2, batch_id: 30, loss is: [0.54294735]\n",
      "[validation] accuracy/loss: 0.8774999380111694/0.3529694676399231\n",
      "epoch: 3, batch_id: 0, loss is: [0.45391327]\n",
      "epoch: 3, batch_id: 10, loss is: [0.60211354]\n",
      "epoch: 3, batch_id: 20, loss is: [0.3273654]\n",
      "epoch: 3, batch_id: 30, loss is: [0.11545569]\n"
     ]
    }
   ],
   "source": [
    "with fluid.dygraph.guard():\n",
    "    model = GoogLeNet(\"GoogLeNet\")\n",
    "\n",
    "train(model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "通过运行结果可以发现，使用GoogLeNet在眼疾筛查数据集iChallenge-PM上，loss能有效的下降，经过5个epoch的训练，在验证集上的准确率可以达到95%左右。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## ResNet\n",
    "\n",
    "ResNet是2015年ImageNet比赛的冠军，将识别错误率降低到了3.6%，这个结果甚至超出了正常人眼识别的精度。\n",
    "\n",
    "通过前面几个经典模型学习，我们可以发现随着深度学习的不断发展，模型的层数越来越多，网络结构也越来越复杂。那么是否加深网络结构，就一定会得到更好的效果呢？从理论上来说，假设新增加的层都是恒等映射，只要原有的层学出跟原模型一样的参数，那么深模型结构就能达到原模型结构的效果。换句话说，原模型的解只是新模型的解的子空间，在新模型解的空间里应该能找到比原模型解对应的子空间更好的结果。但是实践表明，增加网络的层数之后，训练误差往往不降反升。\n",
    "\n",
    "Kaiming He等人提出了残差网络ResNet来解决上述问题，其基本思想如 **图6**所示。\n",
    "* 图6(a)：表示增加网络的时候，将x映射成$y=F(x)$输出。\n",
    "* 图6(b)：对图6(a)作了改进，输出$y=F(x) + x$。这时不是直接学习输出特征y的表示，而是学习$y-x$。\n",
    "  - 如果想学习出原模型的表示，只需将F(x)的参数全部设置为0，则$y=x$是恒等映射。\n",
    "  - $F(x) = y - x$也叫做残差项，如果$x\\rightarrow y$的映射接近恒等映射，图6(b)中通过学习残差项也比图6(a)学习完整映射形式更加容易。\n",
    "\n",
    "<br></br>\n",
    "<center><img src=\"https://ai-studio-static-online.cdn.bcebos.com/831ee61be4bb4c77b14b276fb57db941a35e8b5a340a4f74b31539bf14c00b8b\" width = \"300\"></center>\n",
    "<center><br>图6：残差块设计思想</br></center>\n",
    "<br></br>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "图6(b)的结构是残差网络的基础，这种结构也叫做残差块（residual block）。输入x通过跨层连接，能更快的向前传播数据，或者向后传播梯度。残差块的具体设计方案如 **图**7 所示，这种设计方案也成称作瓶颈结构（BottleNeck）。\n",
    "<br></br>\n",
    "<center><img src=\"https://ai-studio-static-online.cdn.bcebos.com/44fda3ea71da48c5bb7c942e3f7a824e209da50116c14d88918440e9d7f4f28a\" width = \"500\"></center>\n",
    "<center><br>图7：残差块结构示意图</br></center>\n",
    "<br></br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "下图表示出了ResNet-50的结构，一共包含49层卷积和1层全连接，所以被称为ResNet-50。\n",
    "\n",
    "<br></br>\n",
    "<center><img src=\"https://ai-studio-static-online.cdn.bcebos.com/80d80204dda54528a1eea47073e712208b77f4b27d3b45e3901cc07c2ff9b1dc\" width = \"700\"></center>\n",
    "<center><br>图8：ResNet-50模型网络结构示意图</br></center>\n",
    "<br></br>\n",
    "\n",
    "ResNet-50的具体实现如下代码所示："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# -*- coding:utf-8 -*-\n",
    "\n",
    "# ResNet模型代码\n",
    "import numpy as np\n",
    "import paddle\n",
    "import paddle.fluid as fluid\n",
    "from paddle.fluid.layer_helper import LayerHelper\n",
    "from paddle.fluid.dygraph.nn import Conv2D, Pool2D, BatchNorm, FC\n",
    "from paddle.fluid.dygraph.base import to_variable\n",
    "\n",
    "# ResNet中使用了BatchNorm层，在卷积层的后面加上BatchNorm以提升数值稳定性\n",
    "# 定义卷积批归一化块\n",
    "class ConvBNLayer(fluid.dygraph.Layer):\n",
    "    def __init__(self,\n",
    "                 name_scope,\n",
    "                 num_channels,\n",
    "                 num_filters,\n",
    "                 filter_size,\n",
    "                 stride=1,\n",
    "                 groups=1,\n",
    "                 act=None):\n",
    "        \"\"\"\n",
    "        name_scope, 模块的名字\n",
    "        num_channels, 卷积层的输入通道数\n",
    "        num_filters, 卷积层的输出通道数\n",
    "        stride, 卷积层的步幅\n",
    "        groups, 分组卷积的组数，默认groups=1不使用分组卷积\n",
    "        act, 激活函数类型，默认act=None不使用激活函数\n",
    "        \"\"\"\n",
    "        super(ConvBNLayer, self).__init__(name_scope)\n",
    "\n",
    "        # 创建卷积层\n",
    "        self._conv = Conv2D(\n",
    "            self.full_name(),\n",
    "            num_filters=num_filters,\n",
    "            filter_size=filter_size,\n",
    "            stride=stride,\n",
    "            padding=(filter_size - 1) // 2,\n",
    "            groups=groups,\n",
    "            act=None,\n",
    "            bias_attr=False)\n",
    "\n",
    "        # 创建BatchNorm层\n",
    "        self._batch_norm = BatchNorm(self.full_name(), num_filters, act=act)\n",
    "\n",
    "    def forward(self, inputs):\n",
    "        y = self._conv(inputs)\n",
    "        y = self._batch_norm(y)\n",
    "        return y\n",
    "\n",
    "# 定义残差块\n",
    "# 每个残差块会对输入图片做三次卷积，然后跟输入图片进行短接\n",
    "# 如果残差块中第三次卷积输出特征图的形状与输入不一致，则对输入图片做1x1卷积，将其输出形状调整成一致\n",
    "class BottleneckBlock(fluid.dygraph.Layer):\n",
    "    def __init__(self,\n",
    "                 name_scope,\n",
    "                 num_channels,\n",
    "                 num_filters,\n",
    "                 stride,\n",
    "                 shortcut=True):\n",
    "        super(BottleneckBlock, self).__init__(name_scope)\n",
    "        # 创建第一个卷积层 1x1\n",
    "        self.conv0 = ConvBNLayer(\n",
    "            self.full_name(),\n",
    "            num_channels=num_channels,\n",
    "            num_filters=num_filters,\n",
    "            filter_size=1,\n",
    "            act='relu')\n",
    "        # 创建第二个卷积层 3x3\n",
    "        self.conv1 = ConvBNLayer(\n",
    "            self.full_name(),\n",
    "            num_channels=num_filters,\n",
    "            num_filters=num_filters,\n",
    "            filter_size=3,\n",
    "            stride=stride,\n",
    "            act='relu')\n",
    "        # 创建第三个卷积 1x1，但输出通道数乘以4\n",
    "        self.conv2 = ConvBNLayer(\n",
    "            self.full_name(),\n",
    "            num_channels=num_filters,\n",
    "            num_filters=num_filters * 4,\n",
    "            filter_size=1,\n",
    "            act=None)\n",
    "\n",
    "        # 如果conv2的输出跟此残差块的输入数据形状一致，则shortcut=True\n",
    "        # 否则shortcut = False，添加1个1x1的卷积作用在输入数据上，使其形状变成跟conv2一致\n",
    "        if not shortcut:\n",
    "            self.short = ConvBNLayer(\n",
    "                self.full_name(),\n",
    "                num_channels=num_channels,\n",
    "                num_filters=num_filters * 4,\n",
    "                filter_size=1,\n",
    "                stride=stride)\n",
    "\n",
    "        self.shortcut = shortcut\n",
    "\n",
    "        self._num_channels_out = num_filters * 4\n",
    "\n",
    "    def forward(self, inputs):\n",
    "        y = self.conv0(inputs)\n",
    "        conv1 = self.conv1(y)\n",
    "        conv2 = self.conv2(conv1)\n",
    "\n",
    "        # 如果shortcut=True，直接将inputs跟conv2的输出相加\n",
    "        # 否则需要对inputs进行一次卷积，将形状调整成跟conv2输出一致\n",
    "        if self.shortcut:\n",
    "            short = inputs\n",
    "        else:\n",
    "            short = self.short(inputs)\n",
    "\n",
    "        y = fluid.layers.elementwise_add(x=short, y=conv2)\n",
    "        layer_helper = LayerHelper(self.full_name(), act='relu')\n",
    "        return layer_helper.append_activation(y)\n",
    "\n",
    "# 定义ResNet模型\n",
    "class ResNet(fluid.dygraph.Layer):\n",
    "    def __init__(self, name_scope, layers=50, class_dim=1):\n",
    "        \"\"\"\n",
    "        name_scope，模块名称\n",
    "        layers, 网络层数，可以是50, 101或者152\n",
    "        class_dim，分类标签的类别数\n",
    "        \"\"\"\n",
    "        super(ResNet, self).__init__(name_scope)\n",
    "        self.layers = layers\n",
    "        supported_layers = [50, 101, 152]\n",
    "        assert layers in supported_layers, \\\n",
    "            \"supported layers are {} but input layer is {}\".format(supported_layers, layers)\n",
    "\n",
    "        if layers == 50:\n",
    "            #ResNet50包含多个模块，其中第2到第5个模块分别包含3、4、6、3个残差块\n",
    "            depth = [3, 4, 6, 3]\n",
    "        elif layers == 101:\n",
    "            #ResNet101包含多个模块，其中第2到第5个模块分别包含3、4、23、3个残差块\n",
    "            depth = [3, 4, 23, 3]\n",
    "        elif layers == 152:\n",
    "            #ResNet50包含多个模块，其中第2到第5个模块分别包含3、8、36、3个残差块\n",
    "            depth = [3, 8, 36, 3]\n",
    "        \n",
    "        # 残差块中使用到的卷积的输出通道数\n",
    "        num_filters = [64, 128, 256, 512]\n",
    "\n",
    "        # ResNet的第一个模块，包含1个7x7卷积，后面跟着1个最大池化层\n",
    "        self.conv = ConvBNLayer(\n",
    "            self.full_name(),\n",
    "            num_channels=3,\n",
    "            num_filters=64,\n",
    "            filter_size=7,\n",
    "            stride=2,\n",
    "            act='relu')\n",
    "        self.pool2d_max = Pool2D(\n",
    "            self.full_name(),\n",
    "            pool_size=3,\n",
    "            pool_stride=2,\n",
    "            pool_padding=1,\n",
    "            pool_type='max')\n",
    "\n",
    "        # ResNet的第二到第五个模块c2、c3、c4、c5\n",
    "        self.bottleneck_block_list = []\n",
    "        num_channels = 64\n",
    "        for block in range(len(depth)):\n",
    "            shortcut = False\n",
    "            for i in range(depth[block]):\n",
    "                bottleneck_block = self.add_sublayer(\n",
    "                    'bb_%d_%d' % (block, i),\n",
    "                    BottleneckBlock(\n",
    "                        self.full_name(),\n",
    "                        num_channels=num_channels,\n",
    "                        num_filters=num_filters[block],\n",
    "                        stride=2 if i == 0 and block != 0 else 1, # c3、c4、c5将会在第一个残差块使用stride=2；其余所有残差块stride=1\n",
    "                        shortcut=shortcut))\n",
    "                num_channels = bottleneck_block._num_channels_out\n",
    "                self.bottleneck_block_list.append(bottleneck_block)\n",
    "                shortcut = True\n",
    "\n",
    "        # 在c5的输出特征图上使用全局池化\n",
    "        self.pool2d_avg = Pool2D(\n",
    "            self.full_name(), pool_size=7, pool_type='avg', global_pooling=True)\n",
    "\n",
    "        # stdv用来作为全连接层随机初始化参数的方差\n",
    "        import math\n",
    "        stdv = 1.0 / math.sqrt(2048 * 1.0)\n",
    "        # 创建全连接层，输出大小为类别数目\n",
    "        self.out = FC(self.full_name(),\n",
    "                      size=class_dim,\n",
    "                      param_attr=fluid.param_attr.ParamAttr(\n",
    "                          initializer=fluid.initializer.Uniform(-stdv, stdv)))\n",
    "\n",
    "        \n",
    "    def forward(self, inputs):\n",
    "        y = self.conv(inputs)\n",
    "        y = self.pool2d_max(y)\n",
    "        for bottleneck_block in self.bottleneck_block_list:\n",
    "            y = bottleneck_block(y)\n",
    "        y = self.pool2d_avg(y)\n",
    "        y = self.out(y)\n",
    "        return y\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "start training ... \n",
      "epoch: 0, batch_id: 0, loss is: [0.8009904]\n",
      "epoch: 0, batch_id: 10, loss is: [0.80373573]\n",
      "epoch: 0, batch_id: 20, loss is: [0.68027526]\n",
      "epoch: 0, batch_id: 30, loss is: [0.6517928]\n",
      "[validation] accuracy/loss: 0.7600000500679016/0.5742934346199036\n",
      "epoch: 1, batch_id: 0, loss is: [0.6781621]\n",
      "epoch: 1, batch_id: 10, loss is: [0.55741334]\n",
      "epoch: 1, batch_id: 20, loss is: [0.6622879]\n",
      "epoch: 1, batch_id: 30, loss is: [0.30561048]\n",
      "[validation] accuracy/loss: 0.875/0.3026508092880249\n",
      "epoch: 2, batch_id: 0, loss is: [0.42329866]\n",
      "epoch: 2, batch_id: 10, loss is: [0.5172106]\n",
      "epoch: 2, batch_id: 20, loss is: [0.34873646]\n",
      "epoch: 2, batch_id: 30, loss is: [0.21616928]\n",
      "[validation] accuracy/loss: 0.9475000500679016/0.1857086569070816\n",
      "epoch: 3, batch_id: 0, loss is: [0.40565234]\n",
      "epoch: 3, batch_id: 10, loss is: [0.5787815]\n",
      "epoch: 3, batch_id: 20, loss is: [0.57527375]\n",
      "epoch: 3, batch_id: 30, loss is: [0.28399172]\n",
      "[validation] accuracy/loss: 0.9449999928474426/0.16202837228775024\n",
      "epoch: 4, batch_id: 0, loss is: [1.2871808]\n",
      "epoch: 4, batch_id: 10, loss is: [0.11487567]\n",
      "epoch: 4, batch_id: 20, loss is: [0.05519993]\n",
      "epoch: 4, batch_id: 30, loss is: [0.31190404]\n",
      "[validation] accuracy/loss: 0.9274999499320984/0.2015242725610733\n"
     ]
    }
   ],
   "source": [
    "with fluid.dygraph.guard():\n",
    "    model = ResNet(\"ResNet\")\n",
    "\n",
    "train(model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "通过运行结果可以发现，使用ResNet在眼疾筛查数据集iChallenge-PM上，loss能有效的下降，经过5个epoch的训练，在验证集上的准确率可以达到95%左右。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# 小结\n",
    "\n",
    "在这一节里，给读者介绍了几种经典的图像分类模型，分别是LeNet, AlexNet, VGG, GoogLeNet和ResNet，并将它们应用到眼疾筛查数据集上。除了LeNet不适合大尺寸的图像分类问题之外，其它几个模型在此数据集上损失函数都能显著下降，在验证集上的预测精度在90%左右。如果读者有兴趣的话，可以进一步调整学习率和训练轮数等超参数，观察是否能够得到更高的精度。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## 参考文献\n",
    "\n",
    "[1] Yann LeCun, Léon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learn- ing applied to document recognition. Proc. of the IEEE, 86(11):2278–2324, 1998 \n",
    "\n",
    "[2] Alex Krizhevsky, Ilya Sutskever, and Geoffrey E. Hinton. Imagenet classification with deep convolutional neural networks. In Advances in Neural Information Processing Systems, pages 1097–1105, 2012. \n",
    "\n",
    "[3] Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014b. \n",
    "\n",
    "[4]Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolu- tions. In Proc. of the IEEE Conference on Computer Vision and Pattern Recognition, pages 1–9, 2015. \n",
    "\n",
    "[5] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for im- age recognition. In Proc. of the IEEE Conference on Computer Vision and Pattern Recognition, pages 770–778, 2016a. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# 作业\n",
    "\n",
    "1、如果将LeNet中中间层的激活函数Sigmoid换成ReLU，在眼底筛查数据集上将会得到什么样的结果？Loss是否能收敛，ReLU和Sigmoid之间的区别是引起结果不同的原因吗？请发表你的观点"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "PaddlePaddle 1.6.2 (Python 3.5)",
   "language": "python",
   "name": "py35-paddle1.2.0"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
